Virtual-machine technology essentially abstracts the hardware resources and interfaces of a computer system on behalf of one or multiple virtual machines, each comprising one or more application programs and an operating system. The recent emergence of cloud computing services can provide abstract interfaces to enormous collections of geographically dispersed data centers, allowing computational service providers to develop and deploy complex Internet-based services that execute on tens or hundreds of physical servers through abstract cloud-computing interfaces.
Presently, one challenge when attempting to build separate products or distributed systems, is sourcing, delivering and sharing multiple streams of real-time data between multiple layers of middleware and the services they are serving. Typically developers will employ private API's or SDK's to pull or push data to and from products that talk to one another.
In general, platform to platform communication happens over REST for the most part, some older API's also operate over SOAP. Usually, in order for vProduct X's UI to show information from vProduct Y's data, the X UI has to make a request to the X platform, which in turn will make a request to the Y platform for data and then return that data to the X UI as the response to an XHR request. vProduct Y's UI could in turn do the same in reverse (if they were integrated in a bidirectional manner).
Further, applications typically don't publish these SDK's and API's because they are really only designed for internal use, therefore they are proprietary and quickly become technical debt. API changes often quickly break the UI completely, when there are multiple integrations across a number of products, it becomes a slow, painful and drawn out process to align everyone to the new API changes.
Some modern UI frameworks allow for dependency injection across UI's, and as such, developers create services that are injected into controllers. Services often have other services injected into them also. While this pattern works for smaller applications, it quickly becomes deleteriously unmanageable as the application grows in scope and version. For example, Background FIG. 1 illustrates a present example of services and views that have become tightly coupled and significantly difficult to manage.
Thus, modularity becomes difficult to maintain when tens of services are injected in multiple areas.